1. Field of the Invention
The present invention is related to computer graphics hardware for which OPENGL (GRAPHICS LIBRARY) software is an interface thereto, and, in particular, to efficiently recirculating texture cache misses in the computer graphics hardware.
2. Description of the Related Art
Interactive graphics display, in general, is explained in Computer Graphics: Principles and Practices, Foley, vanDam, Feiner, and Hughes, Addison-Wesley, 1992, and in Principles of Interactive Computer Graphics, William M. Newman and Robert F. Sproull, Second Edition, McGraw-Hill Book Company, New York, 1979. Interactive graphics display generally includes a frame buffer storing pixels (or picture elements), a display, and a display controller that transmits the contents of the frame buffer to the display.
The OpenGL graphics system is a software interface to graphics hardware, and is explained in the OpenGL Programming Guide, The Official Guide to Learning OpenGL, Second Edition, Release 1.1, by the OpenGL Architecture Review Board, Jackie Neider, Tom Davis, Mason Woo, Addison-Wesley Developers Press, Reading, Mass., 1997, in the OpenGL Programming Guide, The Official Guide to Learning OpenGL, Release 1, by the OpenGL Architecture Review Board, Jackie Neider, Tom Davis, Mason Woo, Addison-Wesley Publishing Company, Reading, Mass., 1993, and in the OpenGL Reference Manual, The Official Reference Document for OpenGL, Release 1, the OpenGl Architecture Review Board, Addison-Wesley Publishing Company, Reading, Mass., 1993.
A computer model for interpretation of OpenGL commands is a client-server model. An application program being executed by one computer, typically the client computer, issues commands, which are interpreted and processed by another computer, typically the server computer, on which OpenGL is implemented. The client may or may not operate on the same computer as the server. A computer, then, can make calls through an OpenGL software interface to graphics hardware, and the graphics hardware can reside either on the same computer making the calls or on a remote computer.
A tool for describing how data is processed in OpenGL is a processing pipeline. The OpenGL processing pipeline 10 shown in FIG. 1 receives commands, and may store the commands for future processing in a display list 14 or execute the commands immediately. The OpenGL processing pipeline includes an evaluator 16, which approximates curve and surface geometry by evaluating polynomial commands of the input values; per-vertex operations and primitive assembly 18, in which geometric primitives such as points, line segments, and polygons, described by vertices, are processed, such as transforming and lighting the vertices, and clipping the primitives into a viewing volume; rasterization 20 produces a series of frame buffer addresses and associated values, and converts a projected point, line, or polygon, or the pixels of a bitmap or image, to fragments, each corresponding to a pixel in the framebuffer; per-fragment operations 22 performs operations such as conditional updates to the frame buffer 24 based on incoming and previously stored depth values (to effect depth buffering) and blending of incoming pixel colors with stored colors, masking, and other logical operations on pixel values. The final pixel values are then stored in the frame buffer 24.
Pixel operations 26 processes input data from the commands 12 which is in the form of pixels rather than vertices. The result of the pixel operations 26 is stored in texture memory 28, for use in rasterization 20. The resulting fragments are merged into the frame buffer 24 as if the fragments were generated from geometric data.
In addition, if texturing is enabled during rasterization 20, a texel is generated from texture memory 28 for each fragment and applied to the fragment. A texel is a texture element obtained from texture memory and represents the color of the texture to be applied to a corresponding fragment. Texturing maps a portion of a specified texture image onto each primitive.
Texture mapping is accomplished by using the color (Red (R), Green (G), Blue (B), or Alpha (A)) of the texture image at the location indicated by the fragment's (s, t, and r) coordinates. In the case of a 2-dimensional image (2-D image), s and t coordinates are applicable, and in the case of a 3-dimensional image (3-D image), then s, t, and r coordinates are applicable.
An example of a texture image 29 and the coordinates used to access it is shown in FIG. 2. FIG. 2 shows a two-dimensional texture image with n.times.m dimensions of n=3 and m=2. A one-dimensional texture would comprise a single strip. The values, .alpha. and .beta., used in blending adjacent texels to obtain a texture value are also shown. As shown in FIG. 2, values of s and t coordinates are each in the range of 0.0 to 1.0.
In implementing the OpenGL processing pipeline in the related art, a memory stores textures of images. Some of the textures are read into a texture cache during system initialization, while others are read into the texture cache upon a texture cache miss. Although there are many reasons that a system may experience a texture cache fault, such as during heavy minification of an image, most texture cache faults are data-dependent, and depend upon the s, t, and r coordinates which are calculated in the OpenGL processing pipeline.
If a texture cache fault occurs in the related art, then the OpenGL processing pipeline must be stalled to allow the system to retrieve the required data from the memory, and store it in the texture cache. However, the OpenGL processing pipeline is difficult to stall in that a performance penalty is assessed in completing the OpenGL processing pipeline and displaying an image. In addition, stalling the OpenGL processing pipeline would typically require a gated clock and/or a multiplexer to be placed at the input of every flipflop used in the OpenGL processing pipeline.
A problem in the related art is that texture cache faults occur in retrieving textures from the texture cache for pixels already launched in the OpenGL processing pipeline, requiring that the OpenGL processing pipeline be stalled.
Another problem in the related art is that performance of the OpenGL processing pipeline is reduced when texture cache faults occur.
A further problem in the related art is that the OpenGL processing pipeline must be stalled to allow data to be retrieved from the memory and read into the texture cache when texture cache faults occur.